#include <opencv2/opencv.hpp>
#include <iostream>

#include <opencv2/opencv.hpp>
#include <iostream>

std::string detectObjectColor(const cv::Mat& image) {
    // 将图像转换为 HSV 色彩空间
    cv::Mat hsvImage;
    cv::cvtColor(image, hsvImage, cv::COLOR_BGR2HSV);

    // 定义红色、白色和黑色的 HSV 阈值范围
    cv::Mat redMask1, redMask2, whiteMask, blackMask;
    cv::inRange(hsvImage, cv::Scalar(0, 100, 100), cv::Scalar(10, 255, 255), redMask1);   // 低红色
    cv::inRange(hsvImage, cv::Scalar(160, 100, 100), cv::Scalar(179, 255, 255), redMask2); // 高红色
    cv::inRange(hsvImage, cv::Scalar(0, 0, 200), cv::Scalar(180, 30, 255), whiteMask);     // 白色
    cv::inRange(hsvImage, cv::Scalar(0, 0, 0), cv::Scalar(180, 255, 50), blackMask);       // 黑色

    // 合并两个红色掩膜
    cv::Mat redMask;
    cv::bitwise_or(redMask1, redMask2, redMask);

    // 统计每个掩膜中的非零像素数量
    int redCount = cv::countNonZero(redMask);
    int whiteCount = cv::countNonZero(whiteMask);
    int blackCount = cv::countNonZero(blackMask);

    // 输出各颜色的非零像素数量
    std::cout << "Red Count: " << redCount << std::endl;
    std::cout << "White Count: " << whiteCount << std::endl;
    std::cout << "Black Count: " << blackCount << std::endl;

    //默认红色
    std::string color;
    // 判断物体颜色：选择拥有最多像素的颜色
    if (0 != redCount)
    {
        std::cout <<  "Red" << std::endl;
        color = "Red";
    }
    else if (whiteCount > redCount && whiteCount > blackCount)
    {
        std::cout <<  "White" << std::endl;
        color = "White";
    }
    else if (blackCount > redCount && blackCount > whiteCount)
    {
        std::cout <<  "Black" << std::endl;
        color = "Black";
    }
    else
    {
        std::cout <<  "Unknown" << std::endl;
        color = "Unknown";
    }
#if 1
    // 应用掩膜提取红色区域
    cv::Mat redRegion;
    cv::bitwise_and(image, image, redRegion, redMask);

    cv::Mat whiteRegion, blackRegion;
    cv::bitwise_and(image, image, whiteRegion, whiteMask); // 提取白色区域
    cv::bitwise_and(image, image, blackRegion, blackMask); // 提取黑色区域
    // 显示结果
    cv::imshow("Red Region", redRegion);
    cv::imshow("White Region", whiteRegion);
    cv::imshow("Black Region", blackRegion);
#endif
    return color;
}

int main() {
    // 读取图像
    cv::Mat image = cv::imread("white1.jpg");
    if (image.empty()) {
        std::cerr << "Could not open or find the image!" << std::endl;
        return -1;
    }

    // 检测物体颜色
    std::string color = detectObjectColor(image);
    std::cout << "Detected Color: " << color << std::endl;

    // 显示结果
    cv::imshow("Original Image", image);
    cv::waitKey(0);

    return 0;
}




#if 0
int main()
{
    // 读取图片
    cv::Mat image = cv::imread("black.jpg");

    // 检查图片是否成功读取
    if (image.empty())
    {
        std::cerr << "Could not open or find the image!" << std::endl;
        return -1;
    }

    // 将图像转化为HSV色彩空间
    cv::Mat hsvImage;
    cv::cvtColor(image, hsvImage, cv::COLOR_BGR2HSV);
    // 定义红色的HSV范围
    // 定义红色的 HSV 阈值范围
    cv::Mat mask1, mask2;
    cv::inRange(hsvImage, cv::Scalar(0, 100, 100), cv::Scalar(10, 255, 255), mask1);  // 低红色
    cv::inRange(hsvImage, cv::Scalar(160, 100, 100), cv::Scalar(179, 255, 255), mask2); // 高红色

    // 定义白色的 HSV 阈值范围
    cv::Mat whiteMask;
    cv::inRange(hsvImage, cv::Scalar(0, 0, 200), cv::Scalar(180, 30, 255), whiteMask);

    // 定义黑色的 HSV 阈值范围
    cv::Mat blackMask;
    cv::inRange(hsvImage, cv::Scalar(0, 0, 0), cv::Scalar(180, 255, 50), blackMask);

    // 合并两个掩膜
    cv::Mat redMask;
    cv::bitwise_or(mask1, mask2, redMask);

    // 应用掩膜提取红色区域
    cv::Mat redRegion;
    cv::bitwise_and(image, image, redRegion, redMask);

    cv::Mat whiteRegion, blackRegion;
    cv::bitwise_and(image, image, whiteRegion, whiteMask); // 提取白色区域
    cv::bitwise_and(image, image, blackRegion, blackMask); // 提取黑色区域

#if 0
    // 转换为灰度图
    cv::Mat gray;
    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);

    // 二值化图像（使用大津法自动选择阈值）
    cv::Mat binary;
    cv::threshold(gray, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);


    // 查找轮廓
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    cv::findContours(binary, contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

    std::cout << "查找到的轮廓数量:" << contours.size() << std::endl;
    // 绘制轮廓（仅用于验证轮廓检测效果）
    cv::Mat contourImage = cv::Mat::zeros(image.size(), CV_8UC3);
    cv::drawContours(contourImage, contours, -1, cv::Scalar(0, 255, 0), 2);

    // 输出每个轮廓的边缘像素位置
    for (size_t i = 0; i < contours.size(); i++) {
        std::cout << "Contour " << i << ":" << std::endl;
        for (size_t j = 0; j < contours[i].size(); j++) {
            cv::Point point = contours[i][j];
            std::cout << "    Point " << j << ": (" << point.x << ", " << point.y << ")" << std::endl;
        }
    }

    // 显示原图和轮廓图像
    cv::imshow("Original Image", image);
    cv::Mat resizedImage;
    //cv::resize(contourImage, resizedImage, cv::Size(1920, 1080)); // 缩小到 800x600
    cv::resize(maskedImage, resizedImage, cv::Size(1920, 1080)); // 缩小到 800x600
    cv::imshow("Contour Image", resizedImage);
    cv::waitKey(0);
#endif
    // 显示结果
    cv::imshow("Original Image", image);
    //cv::imshow("Red Mask", redMask);
    cv::imshow("Red Region", redRegion);
    cv::imshow("White Region", whiteRegion);
    cv::imshow("Black Region", blackRegion);
    cv::waitKey(0);

    return 0;
}
#endif

#if 0
#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    // 读取图像
    cv::Mat img = cv::imread("red1.jpg");
    if (img.empty())
    {
        std::cout << "Image not found!" << std::endl;
        return -1;
    }

    // 转换为灰度图像
    cv::Mat gray;
    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);

    // 计算x方向和y方向的梯度
    cv::Mat gradX, gradY;
    cv::Sobel(gray, gradX, CV_32F, 1, 0, -1);
    cv::Sobel(gray, gradY, CV_32F, 0, 1, -1);

    // 计算梯度差
    cv::Mat gradient;
    cv::subtract(gradX, gradY, gradient);
    gradient = cv::abs(gradient);  // 取绝对值

    // 转换梯度图像为8位类型
    gradient.convertTo(gradient, CV_8U);

    // 模糊图像
    cv::Mat blurred;
    cv::blur(gradient, blurred, cv::Size(9, 9));

    // 阈值化
    cv::Mat thresh;
    cv::threshold(blurred, thresh, 190, 255, cv::THRESH_BINARY);

    // 形态学闭操作
    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(25, 25));
    cv::Mat closed;
    cv::morphologyEx(thresh, closed, cv::MORPH_CLOSE, kernel);

    // 腐蚀和膨胀操作
    cv::erode(closed, closed, cv::Mat(), cv::Point(-1, -1), 4);
    cv::dilate(closed, closed, cv::Mat(), cv::Point(-1, -1), 4);

    // 轮廓检测
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    cv::findContours(closed, contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
#if 0
    // 找到面积最大的轮廓
    if (contours.empty()) {
        std::cout << "No contours found!" << std::endl;
        return -1;
    }
    std::sort(contours.begin(), contours.end(), [](const std::vector<cv::Point>& c1, const std::vector<cv::Point>& c2) {
        return cv::contourArea(c1) > cv::contourArea(c2);
    });
    std::vector<cv::Point> cnt = contours[0];

    // 绘制轮廓的外接矩形并裁剪
    cv::Rect boundingBox = cv::boundingRect(cnt);
    cv::rectangle(img, boundingBox, cv::Scalar(0, 255, 0), 2);
    cv::Mat croppedImage = img(boundingBox);

    // 显示结果
    cv::imshow("Image", croppedImage);
    cv::waitKey(0);
#else
    // 逐个展示轮廓
    for (size_t i = 0; i < contours.size(); i++)
    {
        cv::Mat displayImage = img.clone();  // 克隆原图以绘制轮廓
        cv::drawContours(displayImage, contours, static_cast<int>(i), cv::Scalar(0, 255, 0), 2); // 绘制轮廓

        // 获取轮廓的边界矩形
        cv::Rect boundingBox = cv::boundingRect(contours[i]);
        cv::rectangle(displayImage, boundingBox, cv::Scalar(255, 0, 0), 2); // 绘制外接矩形

        // 显示当前轮廓图像
        std::string windowName = "Contour " + std::to_string(i + 1);
        cv::imshow(windowName, displayImage);
        cv::waitKey(0);  // 等待用户按键
        cv::destroyWindow(windowName);
    }
#endif
    cv::destroyAllWindows();

    return 0;
}
#endif